package com.agp.test.ForkJoin;

import com.agp.test.ForkJoinTest;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class CountTask extends RecursiveTask<Integer> {
    //阈值
    private static final int THRESHOLD = 2;

    private int start;

    private int end;

    public CountTask(int start, int end) {

        this.start = start;

        this.end = end;

    }

    /**
     * The main computation performed by this task.
     *
     * @return the result of the computation
     */
    @Override
    protected Integer compute() {
        int sum = 0;

        //任务是否足够小
        boolean canCompute = (end - start) <= THRESHOLD;

        if (canCompute) {
            System.out.println(Thread.currentThread().getId());
            //如果任务足够小.
            for (int i = start; i <= end; i++) {

                sum += i;
            }

        } else {
            //如果任务大于阀值，就分裂成两个子任务计算

            int middle = (start + end) / 2;

            CountTask leftTask = new CountTask(start, middle);

            CountTask rightTask = new CountTask(middle + 1, end);

            //执行子任务

            leftTask.fork();

            rightTask.fork();

            //等待子任务执行完，并得到其结果

            int leftResult = leftTask.join();

            int rightResult = rightTask.join();

            //合并子任务

            sum = leftResult + rightResult;

        }

        return sum;
    }

    public static void main(String[] arg) {
        //生成一个计算任务，负责计算1+2+3+4

        CountTask task = new CountTask(1, 100);

        //执行一个任务

        Future<Integer> result = ForkJoinPool.commonPool().submit(task);

        try {
            System.out.println(result.get());
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}
